1. Field of the Invention
The invention relates generally to the field of computer science. More particularly, the invention relates to software. Specifically, a preferred implementation of the invention relates to parameter passing between multiple programs.
2. Discussion of the Related Art
Prior art techniques for exchanging data by passing parameters across multiple programs are known to those skilled in the art. However, there are several problems with these techniques.
One conventional approach to passing parameters between two programs involves one program reading the data of another and vice versa. A first program may make a “call” through an Application Program Interface (API) or a similar mechanism, to a second program. In response, the second program possibly using a “callback” reaches across to either the first program or another program to handle the call. However, many calls and callbacks may be performed to exchange data by passing parameters
For instance, the first program may make a call to the second program and receive a dataset in return. Likewise, if the second program needs a particular data from the first program, in order to return the dataset to the first program, a callback may be performed for that purpose. Such a process of calls and callbacks may continue until all the desired data is exchanged through parameter passing. However, a significant amount of unnecessary time and resources may be wasted to accomplish the desired data exchange or to discover one program may not have what another program is seeking therefrom.
One unsatisfactory approach to addressing these issues involves providing all the parameters required for evaluating a rule, such as a function of a relatively large number of variables, to derive an output. However, in order to evaluate the function, it can be inefficient to pass all the parameters to the function, which selectively utilizes the needed parameters for a selected set of variables.
Another unsatisfactory approach to addressing these issues involves loading an arbitrary number of parameters on a stack. However, such parameter passing to exchange data between multiple programs or processes requires each program or process to be aware of the order and type of the parameters, thereby substantially slowing down the process of passing parameters off the stack.
More specifically, it can be difficult to provide efficient parameter passing, in a variety of environments, including databases and libraries. For example, within an environment having disparate applications, while using a known Application Procedural Interface (API) with a set of predefined callbacks or calling routines, absent a protocol specification, it could be difficult to provide an efficient parameter passing between a single shared entity.
In the semiconductor industry, multiple installed application programs such as software products for electronic design automation may interface with a loader interacting with a model including one or more rules. Integrated circuits (ICs) using deep submicron process have led to the development of an open architecture named Open Library API (OLA). Although OLA provides a comprehensive Application Procedural Interface (API) that can be used by Electronic Design Automation (EDA) tools for the determination of cell and interconnect timing and power characteristics of ICs, performing unnecessary procedures such as calls and/or callbacks, providing all the variables required for evaluating a rule, or use of a stack can cause significant degradation of system performance.
Therefore, as every call or callback between two communicating programs will most likely require a finite amount of time and resources, a relatively large overhead may be involved while exchanging data through parameters. Additionally, if many calls or callbacks are involved, a lot of custom programming may be needed. Even worse, if there is logic or data changes in one program, the interaction for exchanging data through parameters will probably need more custom programming.
What is needed is a solution that permits efficient parameter passing to implement for example, a model having one or more rules, which serve multiple applications. More particularly, a solution is desired for evaluation of a rule which calculates and/or models electrical characteristics, including but not limited to, delay, power, and other silicon device characteristics, without incurring excessive overhead.